/*
 * 文件功能说明：
 * 该文件实现了机器人小车的寻迹功能。通过感为八路灰度传感器检测地面上的黑线，并控制电机的转动方向，使小车沿着黑线行驶。
 * - 通过GPIO控制电机的正转、反转、停止等状态。
 * - 利用定时器周期性地读取八路灰度传感器的值，根据传感器的输入调整小车行驶方向。
 * - 左右轮电机由L9110S驱动，通过GPIO0、GPIO1控制左轮，通过GPIO9、GPIO10控制右轮。
 * - 感为八路灰度传感器通过GPIO32(时钟)和GPIO35(数据)与3861芯片连接，用于检测黑线位置。
 * - 传感器特性：扫白线返回高电平(1)，扫黑线返回低电平(0)
 */

 #include "ohos_init.h"
 #include "cmsis_os2.h"
 #include "iot_gpio.h"
 #include "hi_io.h"
 #include "hi_time.h"
 #include "iot_watchdog.h"
 #include "robot_control.h"
 #include "iot_errno.h"
 #include "hi_pwm.h"
 #include "hi_timer.h"
 #include "iot_pwm.h"

 #define GPIO0 0   // 左轮控制：GPIO0
 #define GPIO1 1   // 左轮控制：GPIO1
 #define GPIO9 9   // 右轮控制：GPIO9
 #define GPIO10 10 // 右轮控制：GPIO10

 // 感为八路灰度传感器GPIO定义
 #define GW_GRAY_GPIO_CLK 11  // 时钟信号：GPIO11
 #define GW_GRAY_GPIO_DAT 12  // 数据信号：GPIO12
 
 #define GPIO_FUNC 0 // GPIO功能模式设置
 #define car_speed_left 0 // 默认左轮停止
 #define car_speed_right 0 // 默认右轮停止
 #define DISTANCE_STOP 20
 extern unsigned char g_car_status; // 小车状态
 extern uint8_t  SR04_flag; // 超声波障碍物标志位（不在这里初始化）
 extern unsigned int get_current_speed_delay(void); // 获取当前速度延时
 extern void reset_sharp_turn_boost(void); // 重置急转弯提速
 unsigned int g_car_speed_left = car_speed_left;
 unsigned int g_car_speed_right = car_speed_right;
 float SR04_distance = 0;

 // 八路灰度传感器相关变量
 unsigned char g_sensor_data = 0;  // 存储8位传感器数据

 // 速度自适应控制变量
 static unsigned char g_original_speed = 0;  // 保存原始速度
 static unsigned char g_speed_reduced = 0;   // 速度是否已降低标志
 unsigned char g_new_sensor_data = 0;
 static int g_turn_counter = 0;              // 转向计数器

 // 锐角弯稳定性控制变量
 static int g_last_turn_direction = 0;       // 上次转向方向：-1左转，0直行，1右转
 static int g_turn_stability_counter = 0;    // 转向稳定性计数器
 static int g_edge_pattern_counter = 0;      // 边缘模式计数器

 // 超声波测量控制变量
 static int g_ultrasonic_counter = 0;        // 超声波测量计数器

 // 全黑线处理变量
 static int g_all_black_count = 0;           // 全黑线检测计数器
 int scan_flag = 0;

 // 黑线延迟检测变量（区分十字路口和终点）
 static unsigned int g_black_line_start_time = 0;    // 黑线检测开始时间
 static unsigned int g_black_line_stable_duration = 0; // 黑线稳定持续时间
 static unsigned char g_black_line_detected = 0;     // 黑线检测状态标志
 #define BLACK_LINE_THRESHOLD_TIME 300               // 终点黑线判断阈值(ms)

 // 摇摆检测变量（解决原地摇摆问题）
 static int g_oscillation_counter = 0;               // 摇摆计数器
 static int g_last_oscillation_direction = 0;        // 上次摇摆方向：-1左，1右，0无
 static unsigned char g_force_forward_flag = 0;      // 强制前进标志
 static int g_force_forward_counter = 0;             // 强制前进计数器
 static unsigned int g_last_reset_time = 0;          // 上次重置时间
 #define OSCILLATION_THRESHOLD 5                     // 摇摆检测阈值（连续3次）
 #define FORCE_FORWARD_DURATION 55                   // 强制前进持续时间（循环次数）
 #define RESET_SHIELD_TIME 125                       // 重置屏蔽时间（ms）

 // 预左转延时控制变量（左转前先直行）
 static int g_pre_left_turn_counter = 0;             // 预左转计数器
 static int g_pre_left_turn_flag = 0;                // 预左转标志
 static int g_last_action_was_forward = 0;           // 上次动作是否为直行
 #define PRE_LEFT_TURN_DURATION 3                    // 预左转直行持续时间（循环次数）

 // 首次黑线检测标志（用于改变搜索方向）
 static unsigned char g_first_black_line_detected = 0;  // 首次检测到黑线的标志位

 // 时间计算相关变量
 static unsigned int g_trace_start_tick = 0;            // trace模式开始时的tick
 static unsigned int g_last_print_update_tick = 0;      // 上次打印更新的tick
 #define SYSTEM_TICK_FREQUENCY 100                      // 系统tick频率（Hz）
 #define PRINT_UPDATE_INTERVAL SYSTEM_TICK_FREQUENCY    // 打印更新间隔（1秒）

 // 智能预左转函数（只在从直行切换到左转时激活延时）
 void smart_car_left(void) {
     // 检查是否需要激活预左转（从直行状态切换到左转）
     if (g_last_action_was_forward && !g_pre_left_turn_flag) {
         // 从直行切换到左转，启动预左转
         g_pre_left_turn_flag = 1;
         g_pre_left_turn_counter = 0;
         car_forward();  // 先直行
         printf("Smart pre-left turn activated: forward phase\r\n");
     } else if (g_pre_left_turn_flag) {
         // 正在预左转过程中
         g_pre_left_turn_counter++;
         if (g_pre_left_turn_counter >= PRE_LEFT_TURN_DURATION) {
             // 预左转完成，执行真正的左转
             car_left();
             g_pre_left_turn_flag = 0;  // 重置标志
             g_last_action_was_forward = 0;  // 更新状态
             printf("Smart pre-left turn completed: turning left\r\n");
         } else {
             car_forward();  // 继续直行
             printf("Smart pre-left turn: forward phase %d/%d\r\n", g_pre_left_turn_counter, PRE_LEFT_TURN_DURATION);
         }
     } else {
         // 直接左转（不是从直行切换过来的）
         car_left();
         g_last_action_was_forward = 0;  // 更新状态
     }
 }

 // 重置预左转状态函数
 void reset_pre_left_turn(void) {
     g_pre_left_turn_flag = 0;
     g_pre_left_turn_counter = 0;
 }

 // 重置首次黑线检测标志函数
 void reset_first_black_line_detection(void) {
     g_first_black_line_detected = 0;
     printf("*** First black line detection flag RESET - Will use LEFT turn for search ***\r\n");
 }

 // 获取trace模式运行时间（秒）
 unsigned int get_trace_running_seconds(void) {
     unsigned int current_tick = hi_get_tick();
     return (current_tick - g_trace_start_tick) / SYSTEM_TICK_FREQUENCY;
 }

 // 获取trace模式运行时间（毫秒）
 unsigned int get_trace_running_milliseconds(void) {
     unsigned int current_tick = hi_get_tick();
     return (current_tick - g_trace_start_tick) * (1000 / SYSTEM_TICK_FREQUENCY);  // 转换为毫秒
 }

 // 打印trace模式信息
 void print_trace_info(void) {
     unsigned int running_seconds = get_trace_running_seconds();

     printf("=== Trace Mode Info ===\r\n");
     printf("Time: %ds\r\n", running_seconds);
     printf("Sensor: 0x%02X\r\n", g_sensor_data);

     if (g_first_black_line_detected) {
         printf("Search: RIGHT\r\n");
     } else {
         printf("Search: LEFT\r\n");
     }
     printf("=======================\r\n");
 }

 /*
  * 函数：gw_gray_serial_read_simple
  * 功能：读取感为八路灰度传感器的8bit数据
  * 输入：无
  * 输出：unsigned char - 8位传感器数据，每bit代表一路传感器状态
  *       bit0-bit7分别对应传感器1-8路，1表示检测到白线，0表示检测到黑线
  */
 static unsigned char gw_gray_serial_read_simple(void)
 {
     unsigned char ret = 0;
     for (int i = 0; i < 8; ++i) {
         IoTGpioSetOutputVal(GW_GRAY_GPIO_CLK, IOT_GPIO_VALUE0); // 输出时钟下降沿

         IotGpioValue data_val;
         IoTGpioGetInputVal(GW_GRAY_GPIO_DAT, &data_val); // 读取数据
         if (data_val == IOT_GPIO_VALUE1) {
             // 修正：传感器标注0~7从左到右，所以第一个读取的应该是传感器0(最左)
             // 将第一个读取的数据存到bit7，第二个存到bit6...这样bit7对应传感器0(左侧)
             ret |= (1 << (7 - i));
         }

         IoTGpioSetOutputVal(GW_GRAY_GPIO_CLK, IOT_GPIO_VALUE1); // 输出时钟上升沿
         hi_udelay(5); // 延时5微秒
     }

     return ret;
 }

 /*
  * 函数：gw_gray_sensor_init
  * 功能：初始化感为八路灰度传感器的GPIO配置
  * 输入：无
  * 输出：无
  */
 static void gw_gray_sensor_init(void)
 {
     // 初始化时钟GPIO为输出模式
     IoTGpioInit(GW_GRAY_GPIO_CLK);
     hi_io_set_func(GW_GRAY_GPIO_CLK, GPIO_FUNC);
     IoTGpioSetDir(GW_GRAY_GPIO_CLK, IOT_GPIO_DIR_OUT);
     IoTGpioSetOutputVal(GW_GRAY_GPIO_CLK, IOT_GPIO_VALUE0);

     // 初始化数据GPIO为输入模式，启用上拉
     IoTGpioInit(GW_GRAY_GPIO_DAT);
     hi_io_set_func(GW_GRAY_GPIO_DAT, GPIO_FUNC);
     IoTGpioSetDir(GW_GRAY_GPIO_DAT, IOT_GPIO_DIR_IN);
     hi_io_set_pull(GW_GRAY_GPIO_DAT, HI_IO_PULL_UP);
 }
 
 /*
  * 函数：timer1_callback
  * 功能：定时器回调函数，用于读取八路灰度传感器的输入值，并根据传感器状态调整电机速度。
  *      根据传感器的检测情况，决定小车的转向或前进状态。
  * 输入：
  *      arg - 回调函数的参数（此处未使用）
  * 输出：无
  *
  * 传感器位置说明（从左到右）：
  * 传感器标注: [0]  [1]  [2]  [3]  [4]  [5]  [6]  [7]
  * bit位置:   bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
  * 左侧 <-------------- 中间 -------------> 右侧
  *
  * 传感器特性：扫白线返回1，扫黑线返回0
  */
 void timer1_callback(unsigned int arg)
 {  

     // 读取八路灰度传感器数据
     g_sensor_data = gw_gray_serial_read_simple();
    
     // 如果超声波检测到障碍物，停止（最高优先级）
     if (SR04_flag == 1) 
     {
         car_stop();
         return; // 直接返回，不执行任何循迹逻辑
     }

     // 获取当前速度，用于自适应控制
     unsigned char current_speed = get_motor_speed_level();
     if (g_original_speed == 0) 
     {
         g_original_speed = current_speed; // 记录初始速度
     }

     // 分析传感器数据进行寻迹控制
     // 计算黑线位置权重，用于精确控制
     int line_position = 0;
     int sensor_count = 0;
     int leftmost_sensor = -1;  // 最左侧检测到黑线的传感器
     int rightmost_sensor = -1; // 最右侧检测到黑线的传感器

     // 计算黑线的加权位置和边界传感器
     // bit7对应传感器0(左侧)，bit0对应传感器7(右侧)
     for (int i = 0; i < 8; i++) 
     {
         if ((g_sensor_data & (1 << i)) == 0) 
         { // 检测到黑线（低电平）
             // 将bit位置转换为传感器位置：bit7->0, bit6->1, ..., bit0->7
             int sensor_pos = 7 - i;
             line_position += sensor_pos * 100; // 位置权重：0-700 (左到右)
             sensor_count++;

             // 记录最左和最右的传感器位置
             if (leftmost_sensor == -1 || sensor_pos < leftmost_sensor) 
             {
                 leftmost_sensor = sensor_pos;
             }
             if (rightmost_sensor == -1 || sensor_pos > rightmost_sensor) 
             {
                 rightmost_sensor = sensor_pos;
             }
         }
     }

     if (sensor_count > 0)
     {
         line_position = line_position / sensor_count; // 计算平均位置
     }

     // 强制前进检测（解决摇摆问题）
     if (g_force_forward_flag)
     {
         // 正在执行强制前进
         reset_sharp_turn_boost(); // 强制前进时重置急转弯提速
         reset_pre_left_turn(); // 强制前进时重置预左转状态
        car_forward();
        g_last_action_was_forward = 1; // 记录直行状态

         g_force_forward_counter++;

         if (g_force_forward_counter >= FORCE_FORWARD_DURATION)
         {
             // 强制前进完成，重置状态
             g_force_forward_flag = 0;
             g_force_forward_counter = 0;
             g_oscillation_counter = 0;
             g_last_oscillation_direction = 0;
         }
         return; // 强制前进期间不执行其他循迹逻辑
     }

     // 根据传感器数据进行寻迹控制
     if (sensor_count == 0)
     {

         // 没有检测到黑线，根据是否已检测过黑线来决定搜索方向
         if (g_first_black_line_detected) {
             // 已经检测过黑线，使用右转搜索
             car_sharp_right();
             printf("No black line detected, searching with RIGHT turn (after first detection)\r\n");
         } else {
             // 还未检测过黑线，使用左转搜索
             car_sharp_left();
             printf("No black line detected, searching with LEFT turn (before first detection)\r\n");
         }

         // 重置全黑线检测计数器和延迟检测状态
         g_all_black_count = 0;
         g_black_line_detected = 0;
         g_black_line_stable_duration = 0;

         // 重置摇摆检测状态（添加时间屏蔽机制）
         unsigned int current_time = hi_get_tick();
         if (current_time - g_last_reset_time >= RESET_SHIELD_TIME)
         {
             g_oscillation_counter = 0;
             g_last_oscillation_direction = 0;
             g_last_reset_time = current_time; // 更新重置时间
         }
     }
    else if (sensor_count == 8) 
    {
    // 检测到8个传感器全部为黑线，可能是十字路口或起点/终点线
            g_all_black_count++;

// 根据速度设置不同的停车阈值
        int stop_threshold;
        if (g_original_speed >= 90) {
            stop_threshold = 8;   // 全速时用较低阈值
        } else if (g_original_speed >= 70) {
            stop_threshold = 12;  // 高速时用中等阈值
        } else {
            stop_threshold = 12;  // 低速时用更高阈值（容错）
        }

        if (g_all_black_count >= stop_threshold) {
            // 连续满足阈值，判断为终点停止线，切换到停止模式
            car_stop();
        
            g_new_sensor_data = gw_gray_serial_read_simple();
            if (g_new_sensor_data == 0xff) {
                // 再次确认读取到全黑，确认为停止线
                g_car_status = CAR_STOP_STATUS;  // 切换到停止状态
            }
        
        } else {
            // 还未达到停止阈值，继续前进
            //car_forward();
            car_sharp_right();
            // 检测到黑线，设置首次检测标志位（35秒后才允许设置）
            if (!g_first_black_line_detected && get_trace_running_seconds() >= 31) {
                g_first_black_line_detected = 1;
            }
        }
    }

     else
     {


         // 重置全黑线检测计数器和延迟检测状态（检测到正常黑线模式）
         g_all_black_count = 0;
         g_black_line_detected = 0;
         g_black_line_stable_duration = 0;

         // 检测急转弯情况
         // 直角弯：传感器1,2或5,6同时检测到黑线
         // 锐角弯：传感器0~4或3~7同时检测到黑线
         int is_sharp_turn = 0;

         // 检测大面积黑线情况（可能是直角弯或交叉路口）
         if (sensor_count >= 6 && sensor_count < 8) {
             // 6-7个传感器检测到黑线，可能是直角弯或交叉路口
             // 高速时需要更谨慎，避免误判
             if (g_original_speed >= 80) {
                 // 高速时先减速，然后根据重心位置转向
                 unsigned char emergency_speed = g_original_speed * 30 / 100; // 紧急降到30%
                 set_motor_speed_level(emergency_speed);
                 g_speed_reduced = 1;
             }

             if (line_position < 350) {
                 // 重心偏左，执行急左转
                 //car_sharp_left();
                 // //car_forward();
                 car_sharp_right();
                 g_last_turn_direction = -1;
                 is_sharp_turn = 1;
             } else {
                 // 重心偏右，执行急右转
                 car_sharp_right();
                 g_last_turn_direction = 1;
                 is_sharp_turn = 1;
             }
         }
         // 简化的锐角弯检测：3-5个传感器时根据重心位置直接判断
         else if (sensor_count >= 3 && sensor_count <= 5) 
         {
             // 简单直接的判断：根据重心位置选择转向，避免复杂逻辑导致摇摆
             if (line_position < 300) 
             {
                 //car_sharp_left(); // 改为强力左转（差速转向）
                 // //car_forward();
                 car_sharp_right();
                 g_last_turn_direction = -1;
                 is_sharp_turn = 1; // 触发减速
             } 
             else if (line_position > 400) 
             {
                 car_sharp_right(); // 改为最强力右转
                 g_last_turn_direction = 1;
                 is_sharp_turn = 1; // 触发减速
             }
            else 
            {
                 // 重心在中间，可能是复杂路况，保持上次方向或直行
                 if (g_last_turn_direction == -1) 
                 {
                     //car_sharp_left(); // 继续强力左转
                     car_forward();
                 } 
                 else if (g_last_turn_direction == 1) 
                 {
                     car_sharp_right(); // 继续最强力右转
                 } 
                 else 
                 {
                     car_forward();
                 }
                 is_sharp_turn = 1; // 触发减速
             }
             g_edge_pattern_counter = 0; // 重置计数器
         }
         // 检测左侧急转弯：传感器0,1,2中有多个检测到黑线
         else if ((leftmost_sensor <= 2) && (sensor_count >= 3) && (line_position < 200)) 
         {
             //car_sharp_left();
             car_forward();
             is_sharp_turn = 1;
         }
         // 检测右侧急转弯：传感器5,6,7中有多个检测到黑线
         else if ((rightmost_sensor >= 5) && (sensor_count >= 3) && (line_position > 500)) 
         {
             car_sharp_right();
             is_sharp_turn = 1;
         }
         // 检测直角弯：传感器1,2同时检测或传感器5,6同时检测
         else if (((leftmost_sensor == 1 && rightmost_sensor == 2) ||
                   (leftmost_sensor == 5 && rightmost_sensor == 6)) && sensor_count == 2) 
        {
             if (leftmost_sensor == 1) 
             {
                 //car_sharp_left();
                 car_forward();
             } 
             else 
             {
                 car_sharp_right();
             }
             is_sharp_turn = 1;
         }
         // 检测特殊情况：传感器0,4或3,7同时检测到（可能是锐角弯）
         else if (((leftmost_sensor == 0 && rightmost_sensor <= 4) ||
                   (leftmost_sensor >= 3 && rightmost_sensor == 7)) && sensor_count >= 4) 
        {
             if (leftmost_sensor == 0) 
             {
                 car_sharp_left();
             } 
             else
            {
                 car_sharp_right();
             }
             is_sharp_turn = 1;
         }

         // 如果不是急转弯，使用常规转向逻辑
         if (!is_sharp_turn) 
         {
             // 根据黑线位置进行转向控制
             // 传感器0-7从左到右，位置权重0-700
             if (line_position < 200) 
             {
                 // 黑线在最左侧（传感器0-1），需要急左转
                 // 高速时更保守，避免识别到弯道外白线
                 if (g_original_speed >= 80 && sensor_count < 3)
                 {
                     smart_car_left(); // 恢复温和左转（带预直行）
                 } else {
                     car_sharp_left(); // 差速左转
                 }
                 g_turn_counter++;
             }
             else if (line_position < 300) 
             {
                 // 黑线在左侧（传感器1-2），需要左转
                 // 高速时减少敏感度，避免摇摆
                 if (g_original_speed >= 80 && line_position > 250) 
                 {
                     car_forward(); // 高速时小偏差继续直行
                     g_last_turn_direction = 0;
                     g_last_action_was_forward = 1; // 记录直行状态
                 } else
                 {
                     smart_car_left(); // 温和左转（带预直行）
                     g_turn_counter++;
                     g_last_turn_direction = -1;
                 }
             }
             else if (line_position > 500) 
             {
                 // 黑线在最右侧（传感器6-7），需要急右转
                 // 所有情况都使用最强力右转
                 car_sharp_right(); // 所有情况都用最强力右转
                 g_turn_counter++;
                 g_last_turn_direction = 1;
             }
             else if (line_position > 400) 
             {
                 // 黑线在右侧（传感器5-6），需要右转
                 // 高速时减少敏感度，避免摇摆
                 if (g_original_speed >= 80 && line_position < 450) 
                 {
                     car_forward(); // 高速时小偏差继续直行
                     g_last_turn_direction = 0;
                     g_last_action_was_forward = 1; // 记录直行状态
                 }
                 else 
                 {
                     car_right(); // 强力右转
                     g_turn_counter++;
                     g_last_turn_direction = 1;
                 }
             }
             else
             {
                 // 黑线在中间（传感器3-4），直行
                 car_forward();
                 reset_sharp_turn_boost(); // 直行时重置急转弯提速
                 reset_pre_left_turn(); // 直行时重置预左转状态
                 g_turn_counter = 0; // 直行时重置转向计数器
                 g_last_turn_direction = 0; // 记录直行状态
                 g_last_action_was_forward = 1; // 记录直行状态
                 g_edge_pattern_counter = 0; // 重置边缘模式计数器
             }
         }
         else
         {
             g_turn_counter++; // 急转弯时增加计数器
         }

         // 摇摆检测逻辑
         int current_turn_direction = 0;
         if (line_position < 350) {
             current_turn_direction = -1; // 左转
         } else if (line_position > 350) {
             current_turn_direction = 1;  // 右转
         } else {
             current_turn_direction = 0;  // 直行
         }

         // 检测方向变化（摇摆）
         if (g_last_oscillation_direction != 0 && current_turn_direction != 0 &&
             g_last_oscillation_direction != current_turn_direction) {
             // 检测到方向变化，增加摇摆计数
             g_oscillation_counter++;

             if (g_oscillation_counter >= OSCILLATION_THRESHOLD) {
                 // 达到摇摆阈值，启动强制前进
                 g_force_forward_flag = 1;
                 g_force_forward_counter = 0;
             }
         } else if (current_turn_direction == 0)
         {
             // 直行时重置摇摆计数（添加时间屏蔽机制）
             unsigned int current_time = hi_get_tick();

             // 检查是否在屏蔽时间内
             if (current_time - g_last_reset_time >= RESET_SHIELD_TIME)
             {
                 g_oscillation_counter = 0;
                 g_last_reset_time = current_time; // 更新重置时间
             }
         }

         // 更新上次摇摆方向
         if (current_turn_direction != 0) {
             g_last_oscillation_direction = current_turn_direction;
         }

     // 速度自适应控制
     if (is_sharp_turn || g_turn_counter > 0) {
         // 检测到转弯，根据转弯类型和原始速度降低速度
         if (!g_speed_reduced) {
             unsigned char reduced_speed;

             if (is_sharp_turn) {
                 // 急转弯：更大幅度降速
                 if (g_original_speed >= 80) {
                     reduced_speed = g_original_speed * 40 / 100; // 高速时降到40%
                 } else {
                     reduced_speed = g_original_speed * 50 / 100; // 中低速时降到50%
                 }
             } else {
                 // 普通转弯：适度降速
                 if (g_original_speed >= 80) {
                     reduced_speed = g_original_speed * 60 / 100; // 高速时降到60%
                 } else {
                     reduced_speed = g_original_speed * 70 / 100; // 中低速时降到70%
                 }
             }

             set_motor_speed_level(reduced_speed);
             g_speed_reduced = 1;
         }
     } else if (g_turn_counter == 0 && sensor_count <= 2) {
         // 连续直行且传感器检测简单，恢复原速度
         if (g_speed_reduced) {
             set_motor_speed_level(g_original_speed);
             g_speed_reduced = 0;
         }
     }
     }

     // 定期打印trace信息（每1秒打印一次）
     unsigned int current_tick = hi_get_tick();
     if (current_tick - g_last_print_update_tick >= PRINT_UPDATE_INTERVAL) {
         print_trace_info();
         g_last_print_update_tick = current_tick;
     }

     // 传感器数据已在读取函数中打印
 }

 /*
  * 函数：trace_module
  * 功能：启动定时器，并通过感为八路灰度传感器反馈来调整小车的前进方向。根据传感器状态控制电机转动。
  * 输入：无
  * 输出：无
  */
 void trace_module(void)
 {
     // 记录trace模式开始时间
     g_trace_start_tick = hi_get_tick();
     g_last_print_update_tick = g_trace_start_tick;

     // 重置首次黑线检测标志位（每次进入循迹模式时重置）
     reset_first_black_line_detection();

     // 初始化感为八路灰度传感器
     gw_gray_sensor_init();

     // 打印初始信息
     print_trace_info();


     unsigned int timer_id1;
     hi_timer_create(&timer_id1);

     // 启动系统周期定时器，每1ms触发timer1_callback任务
     hi_timer_start(timer_id1, HI_TIMER_TYPE_PERIOD, 1, timer1_callback, 0);



    
    //   gpio_control(GPIO0, IOT_GPIO_VALUE1);  // 启动左轮电机
    //   gpio_control(GPIO1, g_car_speed_left); // 控制左轮速度
    //   gpio_control(GPIO9, IOT_GPIO_VALUE1);  // 启动右轮电机
    //   gpio_control(GPIO10, g_car_speed_right); // 控制右轮速度

     while (1)
     {
        //  gpio_control(GPIO1, g_car_speed_left);  // 持续控制左轮速度
        //  gpio_control(GPIO10, g_car_speed_right); // 持续控制右轮速度
        
        // 降低超声波测量频率，避免和循迹冲突

          if (g_car_status != CAR_TRACE_STATUS)  // 如果状态不是寻迹模式，退出循环
          {
              break;
          }

          // 使用速度控制延时
          unsigned int speed_delay = get_current_speed_delay();
          if (speed_delay > 0) {
              hi_sleep(speed_delay);
          } else {
              hi_sleep(20);  // 默认延时
          }
     }
     hi_timer_delete(timer_id1); // 删除定时器
 }
 